/**
 * 倒计时功能
 * @returns cache
 */
/*
// 数据结构
{
  'some_cache': {
    time: '', // 需要对比当前时间确定是否移除
    count: '',
  },
  'some_cache2': {
    time: '',
    count: ''
  }
}
*/

import { PACKAGE_NAME } from '@/global-config/const'

const localMainCache = `${PACKAGE_NAME}:countdowncache`

export function countDownCacheInit() {
  let countDownCache: string | any = localStorage.getItem(localMainCache)
  const fallbackSet = () => {
    localStorage.setItem(localMainCache, '{}')
    return {}
  }
  // 1. 当前无缓存
  if (!countDownCache) {
    return fallbackSet()
  }
  // 2. 当前有缓存 进行解析
  try {
    countDownCache = JSON.parse(countDownCache)
  } catch (err) {
    countDownCache = fallbackSet()
  }
  return countDownCache
}

/**
 * 将当前倒计时缓存，同步到主缓存中
 * @param {*} cacheFlag 当前缓存的名称
 * @param {*} isGetCount 是否是获取倒计时数值 默认false
 * @param {*} option 设置当前值
 * @returns
 */
// eslint-disable-next-line consistent-return
export function countDownCacheHandler(cacheFlag:string, isGetCount: any = false, option?:any) {
  const syncCountDown = (countDownCache: any) => {
    localStorage.setItem(localMainCache, JSON.stringify(countDownCache))
  }
  // 1. 初始化获取countdown参数
  const countDownCache = countDownCacheInit()
  // 2. 加工或获取
  const currentCache = countDownCache[cacheFlag]
  // 已经超过现在时间，则直接失效
  const currentTime = new Date().getTime()
  const savedTime = currentCache?.time || null
  let flowTime = 0 // 流失的时间
  savedTime && (flowTime = currentTime - savedTime)
  // 3. 当前是获取值
  if (isGetCount) {
    if (savedTime) {
      const leftTime = currentCache.count - Math.ceil(flowTime / 1000)
      return leftTime > 0 ? leftTime : 0
    }
    return 0
  }
  // 4. 当前是设置
  if (option) {
    countDownCache[cacheFlag] = option // 数据同步
    syncCountDown(countDownCache) // 本地同步
    return true
  }
  // 5. 当前不是设置，则进行时间的校验
  if (!savedTime) {
    countDownCache[cacheFlag] = {}
    syncCountDown(countDownCache) // 本地同步
    return false
  }
  const flag = flowTime > 59 * 1000 // 当前是否超出
  if (!flag) {
    countDownCache[cacheFlag] = {
      time: currentTime,
      count: Math.floor(flowTime / 1000)
    }
    return true
  }
  countDownCache[cacheFlag] = {}
  syncCountDown(countDownCache) // 本地同步
}

/**
 * 倒计时的处理程序
 * @param params 当前参数
 * @param isStart 是否启动倒计时
 * @param cacheFlag 当前缓存名称
 * @param startNum 启动数值
 */
export function countDownInterval(params:any, isStart:boolean, cacheFlag:string, startNum = 59) {
  const { smsCount, smsTimer } = params
  if (isStart) {
    const setOption = {
      time: new Date().getTime(),
      count: startNum
    }
    smsCount.value = startNum
    countDownCacheHandler(cacheFlag, false, setOption) // 同步当前数据
  } else {
    smsCount.value = countDownCacheHandler(cacheFlag, true)
  }
  smsTimer.value = setInterval(() => {
    const changeFlag = smsCount.value > 0 && countDownCacheHandler(cacheFlag, true)
    if (changeFlag) {
      smsCount.value -= 1
      // 设置参数
      const setOption = {
        time: new Date().getTime(),
        count: smsCount.value
      }
      countDownCacheHandler(cacheFlag, false, setOption)
    } else {
      clearInterval(smsTimer.value)
      smsCount.value = 0
    }
  }, 1000)
}

/**
 * 浏览器页签监听回调
 * @param params 当前参数
 * @param cacheFlag 浏览器缓存
 */
export function browserTabChangeHandler(params:any, cacheFlag:string) {
  const { smsTimer } = params
  if (window.document.visibilityState === 'visible') {
    clearInterval(smsTimer.value) // 先清理定时器
    countDownInterval(params, false, cacheFlag)
  }
}

/**
 * 浏览器tab变化监听
 * @param isSet 是否是设置监听
 * @param params 当前参数
 * @returns
 */
export function browserTabChangeListener(isSet:boolean, params:any) {
  const { browserTabChange, smsTimer } = params
  const { document } = window
  if (isSet) {
    document.addEventListener('visibilitychange', browserTabChange)
    return
  }
  document.removeEventListener('visibilitychange', browserTabChange)
  clearInterval(smsTimer.value)
}

// 清理当前flag
export function clearCurrentCacheFlag(cacheFlag: string) {
  let countDownCache: any = localStorage.getItem(localMainCache)
  if (!countDownCache) return
  try {
    countDownCache = JSON.parse(countDownCache)
  } catch (err) {
    console.log(err)
    countDownCache = {}
  }
  if (!Object.keys(countDownCache).length) return
  // 同步数据
  delete countDownCache[cacheFlag]
  localStorage.setItem(localMainCache, JSON.stringify(countDownCache))
}
